home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / Visual Cafe Pro v1.0 / VISCAFE.BIN / BigDecimal.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-06-19  |  6.5 KB  |  306 lines
  1. package symjava.math;
  2.  
  3. public class BigDecimal extends Number {
  4.    private BigInteger intVal;
  5.    private int scale;
  6.    public static final int ROUND_UP = 0;
  7.    public static final int ROUND_DOWN = 1;
  8.    public static final int ROUND_CEILING = 2;
  9.    public static final int ROUND_FLOOR = 3;
  10.    public static final int ROUND_HALF_UP = 4;
  11.    public static final int ROUND_HALF_DOWN = 5;
  12.    public static final int ROUND_HALF_EVEN = 6;
  13.    public static final int ROUND_UNNECESSARY = 7;
  14.  
  15.    public BigDecimal(String var1) throws NumberFormatException {
  16.       int var2 = var1.indexOf(46);
  17.       if (var2 == -1) {
  18.          this.intVal = new BigInteger(var1);
  19.       } else if (var2 == var1.length() - 1) {
  20.          this.intVal = new BigInteger(var1.substring(0, var1.length() - 1));
  21.       } else {
  22.          String var3 = var1.substring(var2 + 1);
  23.          this.scale = var3.length();
  24.          BigInteger var4 = new BigInteger(var3);
  25.          if (var4.signum() < 0) {
  26.             throw new NumberFormatException();
  27.          } else if (var2 == 0) {
  28.             this.intVal = var4;
  29.          } else if (var1.charAt(0) == '-' && var2 == 1) {
  30.             this.intVal = var4.negate();
  31.          } else {
  32.             String var5 = var1.substring(0, var2);
  33.             BigInteger var6 = new BigInteger(var5);
  34.             if (var1.charAt(0) == '-') {
  35.                var4 = var4.negate();
  36.             }
  37.  
  38.             this.intVal = timesTenToThe(var6, this.scale).add(var4);
  39.          }
  40.       }
  41.    }
  42.  
  43.    public BigDecimal(double var1) throws NumberFormatException {
  44.       if (!Double.isInfinite(var1) && !Double.isNaN(var1)) {
  45.          long var3 = Double.doubleToLongBits(var1);
  46.          int var5 = var3 >> 63 == 0L ? 1 : -1;
  47.          int var6 = (int)(var3 >> 52 & 2047L);
  48.          long var7 = var6 == 0 ? (var3 & (1L << 52) - 1L) << 1 : var3 & (1L << 52) - 1L | 1L << 52;
  49.          var6 -= 1075;
  50.          if (var7 != 0L) {
  51.             while((var7 & 1L) == 0L) {
  52.                var7 >>= 1;
  53.                ++var6;
  54.             }
  55.          }
  56.  
  57.          this.intVal = BigInteger.valueOf((long)var5 * var7);
  58.          if (var6 < 0) {
  59.             this.intVal = this.intVal.multiply(BigInteger.valueOf(5L).pow(-var6));
  60.             this.scale = -var6;
  61.          } else {
  62.             if (var6 > 0) {
  63.                this.intVal = this.intVal.multiply(BigInteger.valueOf(2L).pow(var6));
  64.             }
  65.  
  66.          }
  67.       } else {
  68.          throw new NumberFormatException("Infinite or NaN");
  69.       }
  70.    }
  71.  
  72.    public BigDecimal(BigInteger var1) {
  73.       this.intVal = var1;
  74.    }
  75.  
  76.    public BigDecimal(BigInteger var1, int var2) throws NumberFormatException {
  77.       checkScale(var2);
  78.       this.intVal = var1;
  79.       this.scale = var2;
  80.    }
  81.  
  82.    public static BigDecimal valueOf(long var0, int var2) throws NumberFormatException {
  83.       return new BigDecimal(BigInteger.valueOf(var0), var2);
  84.    }
  85.  
  86.    public static BigDecimal valueOf(long var0) {
  87.       return valueOf(var0, 0);
  88.    }
  89.  
  90.    public BigDecimal add(BigDecimal var1) {
  91.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  92.       matchScale(var2);
  93.       return new BigDecimal(var2[0].intVal.add(var2[1].intVal), var2[0].scale);
  94.    }
  95.  
  96.    public BigDecimal subtract(BigDecimal var1) {
  97.       BigDecimal[] var2 = new BigDecimal[]{this, var1};
  98.       matchScale(var2);
  99.       return new BigDecimal(var2[0].intVal.subtract(var2[1].intVal), var2[0].scale);
  100.    }
  101.  
  102.    public BigDecimal multiply(BigDecimal var1) {
  103.       return new BigDecimal(this.intVal.multiply(var1.intVal), this.scale + var1.scale);
  104.    }
  105.  
  106.    public BigDecimal divide(BigDecimal var1, int var2, int var3) throws ArithmeticException, IllegalArgumentException {
  107.       checkScale(var2);
  108.       if (var3 >= 0 && var3 <= 7) {
  109.          BigDecimal var4;
  110.          BigDecimal var5;
  111.          if (var2 + var1.scale >= this.scale) {
  112.             var4 = this.setScale(var2 + var1.scale);
  113.             var5 = var1;
  114.          } else {
  115.             var4 = this;
  116.             var5 = var1.setScale(this.scale - var2);
  117.          }
  118.  
  119.          BigInteger[] var6 = var4.intVal.divideAndRemainder(var5.intVal);
  120.          BigInteger var7 = var6[0];
  121.          BigInteger var8 = var6[1];
  122.          if (var8.signum() == 0) {
  123.             return new BigDecimal(var7, var2);
  124.          } else if (var3 == 7) {
  125.             throw new ArithmeticException("Rounding necessary");
  126.          } else {
  127.             int var9 = var4.signum() * var5.signum();
  128.             boolean var10;
  129.             if (var3 == 0) {
  130.                var10 = true;
  131.             } else if (var3 == 1) {
  132.                var10 = false;
  133.             } else if (var3 == 2) {
  134.                var10 = var9 > 0;
  135.             } else if (var3 == 3) {
  136.                var10 = var9 < 0;
  137.             } else {
  138.                int var11 = var8.abs().multiply(BigInteger.valueOf(2L)).compareTo(var5.intVal.abs());
  139.                if (var11 < 0) {
  140.                   var10 = false;
  141.                } else if (var11 > 0) {
  142.                   var10 = true;
  143.                } else if (var3 == 4) {
  144.                   var10 = true;
  145.                } else if (var3 == 5) {
  146.                   var10 = false;
  147.                } else {
  148.                   var10 = var7.testBit(0);
  149.                }
  150.             }
  151.  
  152.             return var10 ? new BigDecimal(var7.add(BigInteger.valueOf((long)var9)), var2) : new BigDecimal(var7, var2);
  153.          }
  154.       } else {
  155.          throw new IllegalArgumentException("Invalid rounding mode");
  156.       }
  157.    }
  158.  
  159.    public BigDecimal divide(BigDecimal var1, int var2) throws ArithmeticException, IllegalArgumentException {
  160.       return this.divide(var1, this.scale, var2);
  161.    }
  162.  
  163.    public BigDecimal abs() {
  164.       return this.signum() < 0 ? this.negate() : this;
  165.    }
  166.  
  167.    public BigDecimal negate() {
  168.       return new BigDecimal(this.intVal.negate(), this.scale);
  169.    }
  170.  
  171.    public int signum() {
  172.       return this.intVal.signum();
  173.    }
  174.  
  175.    public int scale() {
  176.       return this.scale;
  177.    }
  178.  
  179.    public BigDecimal setScale(int var1, int var2) throws ArithmeticException, IllegalArgumentException {
  180.       checkScale(var1);
  181.       if (var1 == this.scale) {
  182.          return this;
  183.       } else {
  184.          return var1 > this.scale ? new BigDecimal(timesTenToThe(this.intVal, var1 - this.scale), var1) : this.divide(valueOf(1L), var1, var2);
  185.       }
  186.    }
  187.  
  188.    public BigDecimal setScale(int var1) throws ArithmeticException, IllegalArgumentException {
  189.       return this.setScale(var1, 7);
  190.    }
  191.  
  192.    public BigDecimal movePointLeft(int var1) {
  193.       return var1 >= 0 ? new BigDecimal(this.intVal, this.scale + var1) : this.movePointRight(-var1);
  194.    }
  195.  
  196.    public BigDecimal movePointRight(int var1) {
  197.       return this.scale >= var1 ? new BigDecimal(this.intVal, this.scale - var1) : new BigDecimal(timesTenToThe(this.intVal, var1 - this.scale), 0);
  198.    }
  199.  
  200.    public int compareTo(BigDecimal var1) {
  201.       int var2 = this.signum() - var1.signum();
  202.       if (var2 != 0) {
  203.          return var2 > 0 ? 1 : -1;
  204.       } else {
  205.          BigDecimal[] var3 = new BigDecimal[]{this, var1};
  206.          matchScale(var3);
  207.          return var3[0].intVal.compareTo(var3[1].intVal);
  208.       }
  209.    }
  210.  
  211.    public boolean equals(Object var1) {
  212.       if (!(var1 instanceof BigDecimal)) {
  213.          return false;
  214.       } else {
  215.          BigDecimal var2 = (BigDecimal)var1;
  216.          return this.scale == var2.scale && this.intVal.equals(var2.intVal);
  217.       }
  218.    }
  219.  
  220.    public BigDecimal min(BigDecimal var1) {
  221.       return this.compareTo(var1) < 0 ? this : var1;
  222.    }
  223.  
  224.    public BigDecimal max(BigDecimal var1) {
  225.       return this.compareTo(var1) > 0 ? this : var1;
  226.    }
  227.  
  228.    public int hashCode() {
  229.       return 37 * this.intVal.hashCode() + this.scale;
  230.    }
  231.  
  232.    public String toString() {
  233.       if (this.scale == 0) {
  234.          return this.intVal.toString();
  235.       } else {
  236.          String var2 = this.intVal.abs().toString();
  237.          int var3 = this.signum();
  238.          int var4 = var2.length() - this.scale;
  239.          if (var4 == 0) {
  240.             return (var3 < 0 ? "-0." : "0.") + var2;
  241.          } else {
  242.             StringBuffer var1;
  243.             if (var4 > 0) {
  244.                var1 = new StringBuffer(var2);
  245.                var1.insert(var4, '.');
  246.                if (var3 < 0) {
  247.                   var1.insert(0, '-');
  248.                }
  249.             } else {
  250.                var1 = new StringBuffer(3 - var4 + var2.length());
  251.                var1.append(var3 < 0 ? "-0." : "0.");
  252.  
  253.                for(int var5 = 0; var5 < -var4; ++var5) {
  254.                   var1.append('0');
  255.                }
  256.  
  257.                var1.append(var2);
  258.             }
  259.  
  260.             return var1.toString();
  261.          }
  262.       }
  263.    }
  264.  
  265.    public BigInteger toBigInteger() {
  266.       return this.scale == 0 ? this.intVal : this.intVal.divide(BigInteger.valueOf(10L).pow(this.scale));
  267.    }
  268.  
  269.    public int intValue() {
  270.       return this.toBigInteger().intValue();
  271.    }
  272.  
  273.    public long longValue() {
  274.       return this.toBigInteger().longValue();
  275.    }
  276.  
  277.    public float floatValue() {
  278.       return Float.valueOf(this.toString());
  279.    }
  280.  
  281.    public double doubleValue() {
  282.       return Double.valueOf(this.toString());
  283.    }
  284.  
  285.    private static BigInteger timesTenToThe(BigInteger var0, int var1) {
  286.       return var0.multiply(BigInteger.valueOf(10L).pow(var1));
  287.    }
  288.  
  289.    private static void checkScale(int var0) throws NumberFormatException {
  290.       if (var0 < 0) {
  291.          throw new NumberFormatException("Negative scale");
  292.       }
  293.    }
  294.  
  295.    private static void matchScale(BigDecimal[] var0) {
  296.       if (var0[0].scale < var0[1].scale) {
  297.          var0[0] = var0[0].setScale(var0[1].scale);
  298.       } else {
  299.          if (var0[1].scale < var0[0].scale) {
  300.             var0[1] = var0[1].setScale(var0[0].scale);
  301.          }
  302.  
  303.       }
  304.    }
  305. }
  306.